package com.qz.sort;

import java.text.SimpleDateFormat;
import java.time.temporal.Temporal;
import java.util.Date;

/**
 * @Description 选择排序  从小到大
 * @Author Flag
 * @Date: 2021/7/27 15:01
 * @Version: 1.0
 **/
public class SelectSortDome {

    public static void main(String[] args) {
        int [] array = {101,34,119,1,-1,-232};
        int[] ints = selectSort9(array);

        for (int anInt : ints) {

            System.out.print(anInt+" ");
        }
    }

    /**
     * 选择排序，实现从小到大
     * @param array 入参数组
     * @return 返回结果
     */
    public static int[] selectSort(int[] array){

        //定义一个变量，用来存放每次的基准，即最小值
        int minIndex;
        int min;
        int temp;
/*
        //原始数据 101,34,119,1
        minIndex = 0;
        min = array[0];
        for (int i = 0; i < array.length; i++) {
            if(min > array[i]){
                minIndex = i;
                min = array[minIndex];
            }
            if(minIndex != 0){
                temp = array[0];
                array[0] = array[minIndex];
                array[minIndex] = temp;
            }

        }
        //排序后 1 34 119 101
        minIndex = 1;
        min = array[1];
        for (int i = 1; i < array.length ; i++) {
            if(min > array[i]){
                minIndex = i;
                min = array[minIndex];
            }
            if(minIndex != 1){
                temp = array[1];
                array[1] = array[minIndex];
                array[minIndex] = temp;
            }
        }
        // 1 34 119 101
        minIndex = 2;
        min = array[2];
        for (int i = 2; i < array.length ; i++) {
            if(min > array[i]){
                minIndex = i;
                min = array[minIndex];
            }
            if(minIndex != 2){
                temp = array[2];
                array[2] = array[minIndex];
                array[minIndex] = temp;
            }
        }
*/
        //变换形态
        for (int i = 0; i < array.length -1; i++) {
            minIndex = i;
            min = array[minIndex];
            for (int j = i+1; j < array.length; j++) {
                if(min > array[j]){
                    minIndex = j;
                    min = array[j];
                }
            }
            if(minIndex != i ){
                array[minIndex] = array[i];
                array[i] = min;
            }
        }
        return array;

    }


    /**
     * 选择排序- 按照从小到大的顺序排序
     *
     * 选取数组中最大的一个元素，放到最前面，依次类推
     * @param array
     * @return
     */
    public static int[] selectSort2(int[] array){

        //定义一个变量，用来存储最小值的索引
        int minIndex;
        //定义一个变量，用来存储最小值的数值
        int minValue;
        /**
         * 用来控制模拟的最小值，
         * 因为选择排序，每次都模拟当前队列的第一个元素为最小值，所以从0开始
         * 又因为，如果只剩下最后一个了，就没有必要了。因为 最后一个肯定是一个最值
         */
        for (int i = 0; i < array.length - 1; i++) {
            //模拟第一个是最小值,第一次时,第0个就是最小值
            minIndex = i ;
            minValue = array[i];
            //跳过最小值，遍历后面的每一个元素，这里需要遍历到最后一个
            for (int j = i+1; j < array.length; j++) {
                //如果找到比最小值小的，则更新最小值
                if(minValue > array[j]){
                    minIndex = j;
                    minValue = array[j];
                }
            }
            //找完一轮最小值以后,判断这个minIndex是否变了，如果没有变，则minIndex就是最小的，也就没有了修改的必要
            if(minIndex != i){
                array[minIndex] = array[i];
                array[i] = minValue;
            }
        }

        return array;
    }

    public static int[] selectSort3(int[] array){

        //定义交换变量
        int temp = 0;

        int minIndex = 0;
        for (int i = 0; i < array.length - 1 ; i++) {
            minIndex = i;
            for (int j = i + 1; j < array.length; j++) {
                if(array[minIndex] > array[j]){
                    minIndex = j;
                }
            }
            if(minIndex != i){
                temp = array[minIndex];
                array[minIndex] = array[i];
                array[i]= temp;

            }
        }


        return array;

    }


    /**
     * 选择排序，实现从小到大
     * 
     * 找到队列中最小的值， 然后将他放到指定位置  默认第一个是最小的
     * @param array
     * @return
     */
    public static int[] selectSort4(int[] array){
        int minIndex;
        int temp ;
        //这里需要减一是因为 ：外层循环用来决定取哪个是最小值，如果只有一个值了，也就不用循环了。因为他肯定是最大值或者是最小值
        for (int i = 0; i < array.length -1 ; i++) {
            minIndex = i;
            //内层循环，需要循环完，因为要和后面每一个值比较
            for (int j = i + 1; j < array.length; j++) {
                if(array[j] < array[minIndex]){
                    minIndex = j;
                }

            }
            if(minIndex != i){
                temp = array[minIndex];
                array[minIndex] = array[i];
                array[i] = temp;
            }
        }

        return array;
    }


    /**
     * 选择排序 ，，从小到大
     * 假定第一个作为基准数，然后用第一个和后面对比，直到找到最小的放到最前面
     * @param array
     * @return
     */
    public static int[] selectSort5(int[] array){
        int minIndex;
        int temp;
        for (int i = 0; i < array.length - 1; i++) {
            minIndex = i;
            for (int j = i+1; j < array.length ; j++) {
                if(array[minIndex] > array[j]){
                    minIndex = j;
                }
            }

            if(i!=minIndex){
                temp = array[minIndex];
                array[minIndex] = array[i];
                array[i] = temp;
            }
        }

        return array;
    }

    /**
     * 选择排序  从小到大
     * @param array
     * @return
     */
    public static int[] selectSort6(int[] array){
//        int [] array = {101,34,119,1,-1,-232};
        int minIndex = 0;
        int temp;
        for (int j = 0; j < array.length - 1; j++) {
            minIndex = j;
            for (int i = j + 1; i < array.length; i++) {
                if (array[minIndex] > array[i]){
                    minIndex = i;
                }
            }
            if(minIndex != j){
                temp = array[minIndex];
                array[minIndex] = array[j];
                array[j] = temp;
            }

        }


        return array;
    }

    /**
     * 选择排序，类似于冒泡排序，只不过选择排序是一直找到一个最大的，然后记录这个值，最后的时候在交换
     * @param array
     * @return
     */
    public static int[] selectSort7(int[] array){
        /**
         * 第一轮
         */

//        int minIndex = 0;
//        int temp;
//        for (int j = 1; j < array.length; j++) {
//            if(array[minIndex]> array[j]){
//                minIndex = j;
//            }
//        }
//        if(minIndex != 0 ){
//            temp = array[minIndex];
//            array[minIndex] = array[0];
//            array[0] = temp;
//        }


        /**
         * 第二论
         */
        int minIndex;
        int temp;
        for (int i = 0; i < array.length; i++) {
            minIndex = i;

            for (int j = i+1; j < array.length; j++) {
                if(array[minIndex]> array[j]){
                    minIndex = j;
                }
            }
            if(minIndex != i ){
                temp = array[minIndex];
                array[minIndex] = array[i];
                array[i] = temp;
            }
        }

        return array;


    }


    /**
     * 选择插入 ，找一个最小的，然后插入进去
     * @param array
     * @return
     */
    public static int[] selectSort8(int[] array){
//        int [] array = {101,34,119,1,-1,-232};
        int minIndex;
        int temp;

        for (int i = 0; i < array.length; i++) {
            minIndex=i;
            for (int j = i+1; j < array.length; j++) {
                if(array[j]< array[minIndex]){
                    minIndex = j;
                }
            }

            if(minIndex != i){
                temp = array[minIndex];
                array[minIndex] = array[i];
                array[i] = temp;
            }
        }


        return array;
    }


    /**
     * 选择排序,循环一次 ,找到一个最小的放到后
     * @param array
     * @return
     */
    public static int[] selectSort9(int[] array){
        int minIndex = 0;
        int tem=0;
        for (int i = 0; i < array.length; i++) {
            for (int j = i+1 ; j < array.length ; j++) {

                if(array[minIndex] > array[j]){
                    minIndex = j;
                }
            }
            if(minIndex != i){
                tem = array[minIndex];
                array[minIndex] = array[i];
                array[i] = tem;
            }
        }



        return array;
    }
}
